home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
EnigmA Amiga Run 1996 May
/
EnigmA AMIGA RUN 07 (1996)(G.R. Edizioni)(IT)[!][issue 1996-05][EARSAN CD VI].iso
/
rubriche
/
programm
/
wbclone.c
Wrap
C/C++ Source or Header
|
1996-04-23
|
11KB
|
364 lines
/*****************************************************************************
* Listato 1 *
* Questo listato (preso e modificato dal RKM), mostra come creare una View, *
* completa di ViewPort, ColorMap, BitMap e RastPort per disegnare, copiando *
* quelle del Workbench *
*****************************************************************************/
#include <exec/types.h>
#include <exec/exec.h>
#include <clib/exec_protos.h>
#include <intuition/screens.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <clib/intuition_protos.h>
#include <graphics/gfx.h>
#include <graphics/gfxbase.h>
#include <graphics/view.h>
#include <graphics/gfxnodes.h>
#include <graphics/videocontrol.h>
#include <clib/graphics_protos.h>
#include <stdio.h>
#include <stdlib.h>
/* strutture di utilizzo globale */
struct IntuitionBase *IntuitionBase = NULL;
struct GfxBase *GfxBase = NULL;
/* definizione dei prototipi di funzione */
void Init(void);
void CloseAll(void);
void LiberaView(struct View *view);
/* apre le librerie Intuition.library e Graphics.library */
void Init()
{
if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37L)) == NULL)
{
printf("Non posso aprire la libreria Intuition V37\n");
exit(1);
}
if ((GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",36L)) == NULL)
{
printf("Non posso aprire la libreria Graphics V36\n");
CloseLibrary((struct Library *)IntuitionBase);
exit(1);
}
return;
}
/* Chiude le librerie */
void CloseAll()
{
if (GfxBase != NULL) CloseLibrary((struct Library *)GfxBase);
if (IntuitionBase != NULL) CloseLibrary((struct Library *)IntuitionBase);
return;
}
/* Libera la View view precedentemente allocata */
void LiberaView(struct View *view)
{
struct ViewExtra *ve;
if (view)
{
/* preleva, se esiste, la ViewPortExtra della View */
if (ve = (struct ViewExtra *)GfxLookUp(view))
{
/* Chiude il monitor della ViewExtra */
if (ve -> Monitor) CloseMonitor(ve -> Monitor);
/* Libera la ViewExtra */
GfxFree((struct ExtendedNode *)ve);
}
/* Libera la memoria occupata dalle Copper List create al MakeVPort */
if (view -> LOFCprList) FreeCprList(view -> LOFCprList);
if (view -> SHFCprList) FreeCprList(view -> SHFCprList);
/* Libera la memoria occupata dalla struttura View */
FreeMem(view,sizeof(struct View));
}
return;
}
/* Crea una struttura View adeguatamente inizializzata, con i parametri
della view passata e con la modalita' video ModeID */
struct View *DupView(struct View *v, ULONG ModeID)
{
struct View *view = NULL;
struct ViewExtra *ve = NULL;
struct MonitorSpec *monsp = NULL;
/* Alloca la memoria per la struttura View */
if (view = AllocMem(sizeof(struct View), MEMF_PUBLIC|MEMF_CLEAR))
{
/* Alloca la ViewExtra */
if (ve = GfxNew(VIEW_EXTRA_TYPE))
{
/* Apre il monitor di codice ModeID */
if (monsp = OpenMonitor(NULL, ModeID))
{
/* Inizializza la View */
InitView(view);
/* Copia i parametri della View passata in quella creata */
view -> DyOffset = v -> DyOffset;
view -> DxOffset = v -> DxOffset;
view -> Modes = v -> Modes;
/* Associa la ViewExtra alla View */
GfxAssociate(view, (struct ExtendedNode *)ve);
/* Specifica il monitor aperto nella ViewExtra */
ve -> Monitor = monsp;
}
else printf("Non posso aprire il monitor\n");
}
else printf("Non posso allocare il View Extra\n");
}
else printf("Non posso creare la View\n");
if (view && ve && monsp) return(view);
else
{
LiberaView(view);
return(NULL);
}
}
/* Libera la ViewPort precedentemente allocata */
void LiberaViewPort(struct ViewPort *vp)
{
struct ColorMap *cm;
struct TagItem ti[] =
{
{ VTAG_VIEWPORTEXTRA_GET, NULL },
{ VTAG_END_CM, NULL }
};
if (vp)
{
cm = vp -> ColorMap;
if (cm)
{
/* Preleva la ViewPortExtra eventualmente collegata a questa ViewPort */
if (VideoControl(cm,ti) == NULL)
/* Libera la ViewPortExtra */
GfxFree((struct ExtendedNode *)ti[0].ti_Data);
else
printf("Errore nella funzione VideoControl, non posso liberare la ViewPortExtra\n");
/* Libera la ColorMap */
FreeColorMap(cm);
}
else printf("Errore, non posso liberare la ColorMap\n");
/* Libera la Copper List dedicata a questa ViewPort */
FreeVPortCopLists(vp);
/* Libera la memoria allocata dalla struttura ViewPort */
FreeMem(vp,sizeof(struct ViewPort));
}
return;
}
/* Crea una struttura ViewPort inizializzandola con i parametri della ViewPort
passata e con la modalita' indicata */
struct ViewPort *DupViewPort(struct ViewPort *vp, ULONG ModeID)
{
struct ViewPort *viewport;
struct ViewPortExtra *vpe;
struct ColorMap *cm;
struct TagItem ti[] =
{
{ VTAG_ATTACH_CM_SET,NULL },
{ VTAG_VIEWPORTEXTRA_SET,NULL },
{ VTAG_NORMAL_DISP_SET,NULL },
{ VTAG_END_CM,NULL },
};
struct DimensionInfo query = {0};
ULONG colour[3];
int c;
ULONG gotinfo = NULL;
/* Alloca la memoria per la struttura ViewPort */
if (viewport = AllocMem(sizeof(struct ViewPort), MEMF_CLEAR|MEMF_PUBLIC))
{
/* Alloca la ViewPortExtra */
if (vpe = (struct ViewPortExtra *)GfxNew(VIEWPORT_EXTRA_TYPE))
{
/* Alloca la ColorMap per 256 colori (il massimo utilizzabile) */
if (cm = GetColorMap(256))
{
/* Preleva le informazioni sul display di ModeID e lo inserisce in query */
if (gotinfo = GetDisplayInfoData(NULL, (APTR)&query, sizeof(query), DTAG_DIMS, ModeID))
{
/* Inizializza la ViewPort */
InitVPort(viewport);
/* Copia i parametri della ViewPort passata in quella creata */
viewport -> DWidth = vp -> DWidth;
viewport -> DHeight = vp -> DHeight;
viewport -> DxOffset = vp -> DxOffset;
viewport -> DyOffset = vp -> DyOffset;
viewport -> Modes = vp -> Modes;
viewport -> SpritePriorities = vp -> SpritePriorities;
viewport -> ExtendedModes = vp -> ExtendedModes;
/* Imposta il DisplayClip */
vpe -> DisplayClip = query.TxtOScan;
/* Imposta i ti_Data dei tag da utilizzare per la chiamata
VideoControl che unisce tutto */
ti[0].ti_Data = (ULONG)viewport;
ti[1].ti_Data = (ULONG)vpe;
ti[2].ti_Data = (ULONG)FindDisplayInfo(ModeID);
/* Associa ViewPort, ViewPortExtra e ModeID */
if (VideoControl(cm,ti) != NULL)
printf("Errore in VideoControl per la creazione della ViewPort\n");
/* Copia i colori dalla ColorMap della ViewPort passata a quella creata */
for (c=0; c<256; c++)
{
GetRGB32(vp -> ColorMap, c, 1, colour);
SetRGB32CM(cm, c, colour[0], colour[1], colour[2]);
}
}
else printf("Non posso ottenere il DisplayInfo\n");
}
else printf("Non posso allocare la ColorMap\n");
}
else printf("Non posso allocare la ViewPortExtra\n");
}
else printf("Non posso allocare la ViewPort\n");
if (viewport && vpe && cm && gotinfo) return(viewport);
else
{
LiberaViewPort(viewport);
return(NULL);
}
}
/* Libera la BitMap precedentemente allocata */
void LiberaBitMap(struct BitMap *bm, SHORT width, SHORT height, SHORT depth)
{
int i;
if (bm)
{
/* Libera ogni bitplane */
for (i=0; i<depth; i++)
if (bm -> Planes[i]) FreeRaster(bm -> Planes[i], width, height);
/* Libera la memoria allocata per la struttura BitMap */
FreeMem(bm,sizeof(struct BitMap));
}
return;
}
/* Crea una bitmap di dimensioni date */
struct BitMap *CreateBitMap(SHORT width, SHORT height, SHORT depth)
{
struct BitMap *bm;
PLANEPTR allocated = (PLANEPTR)1;
int i;
/* Alloca la memoria per la struttura BitMap */
if (bm = AllocMem(sizeof(struct BitMap), MEMF_CLEAR|MEMF_PUBLIC))
{
/* Inizializza la BitMap */
InitBitMap(bm, depth, width, height);
/* Alloca i bitplanes */
for (i=0; i<depth; i++)
allocated = (bm -> Planes[i] = AllocRaster(width, height));
if (allocated == NULL)
{
printf("Non posso allocare i bitplanes\n");
LiberaBitMap(bm,width,height,depth);
bm = NULL;
}
}
else printf("Non posso allocare la struttura BitMap\n");
return(bm);
}
/* Mostra la View creata */
void ShowView(struct View *view, struct ViewPort *vp, struct BitMap *bm, SHORT width, SHORT height)
{
struct RastPort *rp;
struct RasInfo *ri;
int i;
/* Alloca la memoria utilizzata per la struttura RastPort */
if (rp = AllocMem(sizeof(struct RastPort), MEMF_CLEAR|MEMF_PUBLIC))
{
/* Alloca la memoria utilizzata per la struttura RasInfo */
if (ri = AllocMem(sizeof(struct RasInfo), MEMF_CLEAR|MEMF_PUBLIC))
{
/* Inizializza la RastPort */
InitRastPort(rp);
/* Associamo la BitMap alla RastPort ed alla RasInfo */
ri -> BitMap = rp -> BitMap = bm;
/* Associamo la RasInfo alla ViewPort */
vp -> RasInfo = ri;
/* Imposta la ViewPort nella View */
view -> ViewPort = vp;
/* Disegna un rettangolo */
SetRast(rp,0);
for (i=0; i<((1 << bm->Depth)-1); i++)
{
SetAPen(rp,i);
Move(rp,i,i);
Draw(rp,width-i,i);
Draw(rp,width-i,height-i);
Draw(rp,i,height-i);
Draw(rp,i,i);
}
/* Crea la View con tutte le CopperList e la mostra */
MakeVPort(view, vp);
MrgCop(view);
LoadView(view);
/* attende un tasto per procedere */
getchar();
/* ridisegna il vecchio display */
RethinkDisplay();
/* Libera la memoria allocata dalla struttura RasInfo */
FreeMem(ri,sizeof(struct RasInfo));
}
else printf("Non posso allocare la RasInfo\n");
/* Libera la memoria allocata dalla struttura RastPort */
FreeMem(rp, sizeof(struct RastPort));
}
else printf("Non posso allocare la RastPort\n");
return;
}
void main(int argc, char *argv[])
{
struct Screen *wb;
struct View *NuovaView;
struct ViewPort *NuovaVP;
struct BitMap *NuovaBitMap;
ULONG ModeID,IbaseLock;
Init();
if (wb = LockPubScreen("Workbench"))
{
ModeID = GetVPModeID(&wb->ViewPort);
IbaseLock = LockIBase(0);
if (NuovaView = DupView(&IntuitionBase->ViewLord, ModeID))
{
UnlockIBase(IbaseLock);
if (NuovaVP = DupViewPort(&wb->ViewPort, ModeID))
{
if (NuovaBitMap = CreateBitMap(wb->Width,wb->Height,wb->BitMap.Depth))
{
ShowView(NuovaView, NuovaVP, NuovaBitMap, wb->Width-1, wb->Height-1);
LiberaBitMap(NuovaBitMap,wb->Width,wb->Height,wb->BitMap.Depth);
}
LiberaViewPort(NuovaVP);
}
LiberaView(NuovaView);
}
else UnlockIBase(IbaseLock);
UnlockPubScreen(NULL, wb);
}
CloseAll();
}